Shareware Grab Bag/Shareware Grab Bag.iso/014/libtools.arc/GRAF.AQM/GRAF.ASM

Assembly Source File | 1984-04-08 | 24.6 KB | 831 lines

    PAGE  60,132
    TITLE    EPSON MX-GRAFTRAX PrtSc, V 2.3a
; GRAF.COM  3/12/83
; INTERRUPT REPLACEMENT FOR PRINT SCREEN FUNCTION ON IBMPC(tm)
;  =====> N O T I C E <=======
;    THIS PROGRAM IS SUPPLIED FOR YOUR PERSONAL AND NON-COMMERCIAL
;    USE ONLY. NO COMMERCIAL USE PERMITTED. USERS OF THIS PROGRAM
;    ARE GRANTED LIMITED RIGHTS TO REPRODUCE AND DISTRIBUTE THIS
;    PROGRAM. IT MAY NOT BE SOLD. PROVIDING THIS PROGRAM FOR
;    CONSIDERATION ANY SORT, INCLUDING COPYING OR DISTRIBUTION FEES,
;    IS SPECIFICALLY PROHIBITED.  THE AUTHOR CANNOT ASSUME RESPONSIBILITY
;    FOR DAMAGES, REAL OR IMAGINED, RESULTING FROM THE USE OF THIS PROGRAM.
;  =====> ENDNOTICE <=========
;
;    PLEASE SEND PROBLEM REPORTS AND SUGGESTIONS TO:
;        MARTY SMITH
;        310 CINNAMON OAK LANE
;        HOUSTON, TEXAS    77079
;        SOURCE ST2259, COMPUSERVE 72155,1214
;        [phone] Office, [phone], Home.
;
;  THIS PROGRAM ORIGINALLY DESIGNED FOR EPSON-MX(tm) SERIES PRINTERS
;  WITH GRAFTRAX80(tm) AND GRAFTRAX+(tm) BIT-PLOT GRAPHIC CAPABILITES.
;  ======> Now modified with conditional compilation and macros for
;  ======> c.itoh(tm) model 8510a and other printers with bit-plot
;  ======> capabilities. See the macro definitions and equates following
;  ======> these messages.
;
;    CHANGE HISTORY:
;    9/18/82 - Buffer in routine for a line of bit-plot bytes to allow for
;  checking for blank lines replaced by pre-scan routine, saving space.
;    1/24/83 - Modifications for conditional assembly with other printers
;  and C.ITOH 8510a.
;    1/24/83 - Improved error checking for out-of-paper and I/O errors
;  involving printer.
;    1/24/83 - Bug in error check corrected, occuring when routine does
;  error exit and is then called again, resulting in bit-plot data sent in
;  regular mode.
;    3/12/83 - Allow calling as a subroutine. i.e. no shift key depressed.
;  Defaults to small print mode. Can be poked for LARGE.
;
;    THE IBM MACRO ASSEMBLER(tm) AND LINK(tm) WILL PRODUCE
;    GRAF.EXE, WHICH MUST BE CONVERTED TO A .COM PROGRAM BY
;    THE COMMAND FROM DOS -EXE2BIN-.
;        do this:
;    X>EXE2BIN GRAF.EXE GRAF.COM
;
;    Features:
;  Accepts ESC key exit, prescans to test for blank line
;  left shift prtsc = small graphics, right shift prtsc = big
;  Runs as a .COM type program under dos
;     resident until power down or reset.
;   1 = screen sent horiz. 320 bits in 480 mode
;   2 = screen sent vert. 400 bits double printed in 480 mode
; **************  1 mode **********************
;    DL = masking character
;    DH = count of 25 (physical lines)
;    CX = counter for each line (80)
;    DS = used to index screen at 'b8000'
;   These regs must be preserved during routine
;      (increment each line by adding '14' hex to ds for para
;        boundary of 320 bytes '140')
; **************  2 mode *********************
;    DH = count of 40 (physical lines)
;    CX = counter for each line (100)
;    SI = index to screen via ds
;   These regs must be preserved during routine
;    all output to printer is done from routine -send2-, which uses
;    bios routine int 17h, and provides safe error exit.
;
;  GRAF.COM is designed with the idea that the user's main program is the
;  primary function and GRAF.COM should not cause problems of its own.
;  The author has tried his best to send control back to the main program in
;  the case of errors involving the printer, and to make the program as easy
;  to use as possible.
;
; =======================================================
; =        USER MODIFICATION SECTION.        =
; =    If your printer can treat a byte of data to    =
; =    control the wires on the dot-matrix head you    =
; =    can probably get this working with your printer =
; =    If you have Epson Graftrax or a C.Itoh 8510a,    =
; =    just set the two equates indicated to -true-    =
; =    and compile. Otherwise get out your manual    =
; =    and put the code indicated in the -other-    =
; =    section and set -other- to -true-.        =
; =    **>    The title message starts at label    =
; =    **>    -buffer-. If you set for another    =
; =    **>    printer you should change the        =
; =    **>    greeting to indicate which printer    =
; =    ===> ONLY SET *ONE* CONDITION TO -TRUE- or you    =
; =    will have a real mess!        marty smith    =
; =======================================================

TRUE    EQU    1    ; DON'T CHANGE THESE!
FALSE    EQU    0

; ===============>  A L L  U S E R S  <===================
; ====> SET ONE AND ONLY ONE OF THE FOLLOWING THREE <=====

EPSON    EQU    TRUE
CITOH    EQU    FALSE
OTHER    EQU    FALSE

; Each bit of a byte is mapped to the wire head of the printer.
; If the Epson MX is sent 80h (bit 7), the TOP wire makes a dot.
; If the C.ITOH is sent   01h (bit 0), the TOP wire makes a dot.
; ===============>  A L L  U S E R S  <===================
; =====> SET ONE AND ONLY ONE OF THE FOLLOWING TWO <======

BIT7    EQU    TRUE
BIT0    EQU    FALSE
    ; BIT7 is TRUE for EPSON
    ; BIT0 is TRUE for CITOH

; *****************************
; *  START of -OTHER- SECTION *
; *****************************
;
; ALL routines must set either BIT7 or BIT0.
;   above. If your printer can't see bit 7 or 0 as the top wire, you
;   will probably have quite a time getting this routine to work.
;
; OLINE Resets line spacing so that the print head
; will make a continuous line DOWN the page.
; This is the sequence to set the EPSON for this. (ESC A 8)
; SEND2 sends the byte in AL to the printer for ALL routines.
; It uses the INT 17h routine in order to avoid DOS's extra line
; feeds and CR's. Set for LPT1: Change SEND2 to redirect. DX=0=LPT1,1=LPT2
OLINE    MACRO
    MOV    AL,27
    CALL    SEND2
    MOV    AL,65
    CALL    SEND2
    MOV    AL,8
    CALL    SEND2
    ENDM

; ORLINE restores the printer to normal line spacing
; Example is for EPSON (ESC 2)
ORLINE    MACRO
    MOV    AL,27
    CALL    SEND2
    MOV    AL,'2'
    CALL    SEND2
    ENDM

; ORESET reinitializes the printer to default settings, spacings,
; current line becomes Top of Form.
; Is used by LARGE print to allow a series to be printed
; on separate pages. It can be modified by getting rid of label
; TOF: up to but not including     JMP DONE, which is the exit from
; the whole routine. Example is for EPSON. (ESC @)
ORESET    MACRO
    MOV    AL,27
    CALL    SEND2
    MOV    AL,'@'
    CALL    SEND2
    ENDM

; BP1 initiates bit-plot graphics. It tells the printer
; that the next xxx bytes are to be considered bit-plots and not
; regular characters. The small print routine sends 320 bit plot bytes
; to the printer. On the EPSON this is:
; ESC K 64 1   hex 1b 4b 40 1  > 1*256+64=320
; --> the first part indents the page with ordinary spaces
; --> to find spaces take TOTAL_DOTS_PER_LINE - 320. Then / BITS_PER_CHARACTER
; --> Divide this by two and you have the spaces to indent
BP1    MACRO
    MOV    CX,13    ; EPSON ( we've got 320 dots and 480 to work with
INLOP:    MOV    AL,20H    ; 480-320=160 / 6 dots per char. = 26.67 extra
    CALL    SEND2    ; so indent the picture 13 spaces to center
    LOOP    INLOP
    MOV    AL,27
    CALL    SEND2
    MOV    AL,75
    CALL    SEND2
    MOV    AL,64
    CALL    SEND2
    MOV    AL,1
    CALL    SEND2
    ENDM

; BP2.
; The LARGE print sends 400 bit plot bytes to the printer. On the EPSON:
; ESC K 144 1  hex 1b 4b 90 1  > 1*256+144=400
; FIND YOUR INDENT FOR 400 BITS
BP2    MACRO
    MOV    CX,6    ; EPSON ( we've got 400 dots and 480 to work with
INLOP2: MOV    AL,20H    ; 480-400=80 / 6 dots per char. = 13.33 extra
    CALL    SEND2    ; so indent the picture 6 spaces to center
    LOOP    INLOP2
    MOV    AL,27
    CALL    SEND2
    MOV    AL,75
    CALL    SEND2
    MOV    AL,144
    CALL    SEND2
    MOV    AL,1
    CALL    SEND2
    ENDM

; ****************************
; *   END OF -OTHER- SECTION *
; ****************************

;  ***************> START OF ACTUAL CODE <*****************

CSEG    SEGMENT 'CODE'
    ASSUME CS:CSEG
    ORG    100H        ; set up for .COM conversion
INIT    PROC    FAR        ; we're an interrupt routine
    JMP    INITIAL     ; so we have to set up first
BUFFER    DB    '         GRAFTRAX.COM v1.2',10,13
    DB    'EPSON MX-80 GRAFTRAX(tm) Screen Printer.',13,10
    DB    '   Left Sh. PrtSc. = LARGE GRAPHICS',13,10
    DB    '  Right Sh. PrtSc. = small graphics',13,10
    DB    ' Text screen uses regular ROM routine.',13,10
    DB    '   ESCape will exit GRAPHICS print.',13,10,'$'
GOWAIT    DW    0
WHERESI DW    0
PTFLAG    DB    0
ONEOR2    DB    0
DSTOR    DW    0
FUDGE    DD    0
INITIAL:
    MOV    AX,0    ; GET ADDR OF
    MOV    DS,AX    ; PRINT SCREEN ROUTINE
    MOV    SI,14H    ; IN ROM
    MOV    AX,[SI] ; from interrupt table in ram
    MOV    DX,AX    ; in case they change the ROM's!
    INC    SI
    INC    SI
    MOV    AX,[SI]
    MOV    DS,AX
    MOV    AL,0F1H ; MOVE IT TO
    MOV    AH,25H
    INT    21H    ; INT F1H described in Tech. Manual as unused vector
    MOV    AX,CS    ; RESET INT 5
    MOV    DS,AX    ; TO POINT TO
    MOV    AX,OFFSET START ; THIS ROUTINE
    MOV    DX,AX
    MOV    AL,5
    MOV    AH,25H    ; DOS routine to reset int. vector
    INT    21H
    MOV    AX,CS
    MOV    DS,AX
    MOV    AX,OFFSET BUFFER
    MOV    DX,AX
    MOV    AH,9
    INT    21H    ; PRINT GREETING
    MOV    AX,OFFSET LAST    ; last address here
    MOV    DX,AX
    INC    DX
    INT    27H    ; TERMINATE BUT STAY RESIDENT
INIT    ENDP
; --->    ACTUAL INTERRUPT ROUTINE STARTS HERE  <---
START    PROC    FAR    ; Start of main routine--Shift Prt.Sc hit.
    ASSUME CS:CSEG
    STI        ; This follows ROM routine real close
    PUSH    DS
    PUSH    AX    ;SAVE REGS
    PUSH    BX
    PUSH    CX
    PUSH    DX
    PUSH    DI
    PUSH    SI
    PUSH    BP
    MOV    BP,SP    ; Save in case of error for reset
    MOV    AX,50H    ; Check here first to see if
    MOV    DS,AX    ; routine is already in progress
    MOV    SI,0    ; otherwise it will be a mess.
    MOV    AL,01H
    CMP    [SI],AL
    JNZ    NXTS    ; if not we're go for routine
    JMP    EXIT    ; otherwise go back home.
NXTS:    MOV    [SI],AL ; if we're go don't let us start again until done.
    MOV    AH,15    ; Get the current video state.
    INT    10H    ; from the ROM routine,
    CMP    AL,4    ; AL=4-6 are all graphics so we're OK
    JZ    GRAPHIC
    CMP    AL,5
    JZ    GRAPHIC
    CMP    AL,6
    JZ    GRAPHIC
    MOV    AL,0    ; else reset and go to ROM routine.
    MOV    [SI],AL
    INT    0F1H    ; this is where we stored the ROM routine entry.
    JMP    EXIT    ; Do the ROM routine but come back here to leave.
GRAPHIC:
    MOV    AX,40H    ; Get the keyboard shift flag
    MOV    DS,AX    ; segment
    MOV    SI,17H    ; and address
    MOV    AX,[SI] ; pick it up
    AND    AX,3    ; get rid of other stuff
    CMP    AX,0    ; Mod. to create default small
    JNZ    GR1    ; for case where routine is called as
    MOV    AX,1    ; a subroutine.
GR1:    MOV    CS:ONEOR2,AL    ; store for later
    PUSH    AX    ; also here
    MOV    AL,0    ; make sure this starts out as NO print.
    MOV    CS:PTFLAG,AL
    MOV    DL,00H    ; These bits indicate whether R or L Shift is down
    MOV    DH,19H    ; 25 lines of graphic dots at 8 dots per line
    MOV    AX,0B800H ; stored in DX
    MOV    DS,AX    ;SET UP FOR SCREEN PEEK
; Printer setup section to change line spacing to 8/72" for continuous dots
    IF    EPSON
    MOV    AL,27    ; ESC
    CALL    SEND2    ; goes out through INT 17h to avoid DOS processing
    MOV    AL,65    ; A
    CALL    SEND2
    MOV    AL,8    ; 8
    CALL    SEND2
    ENDIF
    IF    CITOH    ; ESC T 16
    MOV    AL,27    ; ESC
    CALL    SEND2    ; goes out through INT 17h to avoid DOS processing
    MOV    AL,'T'  ; T
    CALL    SEND2
    MOV    AL,'1'  ; 1
    CALL    SEND2
    MOV    AL,'6'  ; 6
    CALL    SEND2
    MOV    AL,27
    CALL    SEND2
    MOV    AL,62    ; Set printer to unidirectional for dot alignment
    CALL    SEND2
    ENDIF
    IF    OTHER
    OLINE
    ENDIF
    POP    AX    ; get back which routine
    CMP    AL,2    ; Left Shift Prt Sc means LARGE graphic print
    JZ    MAIN2    ; so hop over there if so.
; START OF small GRAPHICS PRINT ROUTINE.
; This routine scans across the screen from left to right,
; building an EPSON bit plot byte out of IBM screen dots.
; EPSON wire head        IBM screen color dots
; TOP     o  128  80h bit 7    | 00 | 01 | 10 | 11 | = 4 dots, one byte
;     o   64  40h  "  6
; one     o   32  20h  "  5      ibm dots go one raster line then the next
; bit     o   16  10h  "  4      EVEN line, ie 0, 2, 4 etc.
; plot     o    8  08h  "  3
; byte     o    4  04h  "  2      then you go back and do 1, 3, 5 etc.
;     o    2  02h  "  1
; BOTTOM o    1  01h  "  0      At loc. 0000h are 4 dots, 0,0|0,1|0,2|0,3
;                At loc. 2000h are 4 dots, 1,0|1,1|1,2|1,3
;
MAIN:    MOV    CX,80    ; 80 x 4 = 320 dots.
MLOOP:    MOV    DL,0C0H ; 11000000b
    CALL    TST4    ; see if this comes back <> 0
    MOV    AL,AH    ; we are testing bit patterns for one screen byte
    CALL    SEND    ; don't send to printer unless something to send
    MOV    DL,30H    ; 00110000b
    CALL    TST4    ; each byte is 4 dots
    MOV    AL,AH    ; so we test for each dot in a byte
    CALL    SEND    ; send sets PTFLAG if there is a dot on the line
    MOV    DL,0CH    ; 00001100b
    CALL    TST4    ; then resets to start of line and starts printing
    MOV    AL,AH    ; AL is the bit plot byte being built
    CALL    SEND
    MOV    DL,03H    ; 00000011b
    CALL    TST4    ; TST4 scans down 8 screen dot lines each time called
    MOV    AL,AH
    CALL    SEND
    LOOP    MLOOP    ; 80 bytes make 320 dots
    CALL    LFCR    ; this is a good old regular line feed/carriage return
    CALL    BREAK?    ; see if someone hit ESC key. If so take early exit
    OR    AL,AL
    DEC    DH    ; DL is line counter
    CMP    DH,0    ; when it goes 0 we're through
    JZ    DONE    ; reset everything and do an IRET
    MOV    AX,DS    ; otherwise bump the SEGMENT reg so that location
    ADD    AX,14H    ; 0 is the start of the next line
    MOV    DS,AX    ; X'140' = 320
    JMP    MAIN    ; and do this 80 times (80x4=320)
DONE:    MOV    AX,0
; This is the common exit for both routines, Printer is restored.
DONE1:    PUSH    AX    ; save AX cause it has error exit flag
; EPSON command to reset printer to 6 lines/in. = ESC 2 (1b 32)
    IF    EPSON
    MOV    AL,27    ; RESET PRINTER, RESTORE REGS
    CALL    SEND2
    MOV    AL,32H
    CALL    SEND2
    ENDIF
; FOR CITOH MAKE SURE BIDIRECTIONAL PRINTING IS RESTORED
    IF    CITOH
    MOV    AL,27
    CALL    SEND2
    MOV    AL,'A'
    CALL    SEND2
    MOV    AL,27
    CALL    SEND2
    MOV    AL,60
    CALL    SEND2
    ENDIF
    IF    OTHER
    ORLINE
    ENDIF
EDONE:    MOV    AX,50H    ; Set end of PrtSc indication
    MOV    DS,AX    ; OK to come back and do again
    MOV    SI,0
    POP    AX
    MOV    [SI],AL
EXIT:    POP    BP
    POP    SI    ; restore regs and return to caller
    POP    DI
    POP    DX
    POP    CX
    POP    BX
    POP    AX
    POP    DS
    IRET        ; were an interrupt routine so we IRET
; START OF LARGE PRINT ROUTINE
; +-------------+
; | ^ ^     |  This time we scan from 199,0 to 0,0
; | ^ ^     |  and go across
; | ^ ^     |  o  o    x  x    o  x    x  x   These are representations
; | | |     |  o  o    o  o    x  o    x  x   of one color dot.
; +-------------+    0         1         2         3       Palettes
MAIN2:    MOV    DH,80    ; we have 80 colunms x 25 lines here
    MOV    CS:WHERESI,3EF0H ; SI is our index
    MOV    SI,CS:WHERESI
MAIN2A: MOV    CX,64H    ; 100
MLOOP2: MOV    AL,[SI] ; idea is to get a byte starting at screen BOTTOM
    IF    BIT0
    CALL    REVERSE ; Bits have to be reversed on wire 0 type
    ENDIF
    CALL    SEND    ; send it since these resemble bit plot bytes
    CALL    FLIPFLOP ; then reverse(sort of) this byte and send it
    CALL    SEND    ; again.
    MOV    CS:GOWAIT,SI ; store SI for next EVEN raster line
    SUB    SI,2000H ; subtract 2000h for the next ODD raster line
    MOV    AL,[SI] ; and do the same here
    IF    BIT0
    CALL    REVERSE
    ENDIF
    CALL    SEND
    CALL    FLIPFLOP
    CALL    SEND
    MOV    SI,CS:GOWAIT ; get back the EVEN line
    SUB    SI,80    ; advance UP the screen one line (say 199,0 to 197,0)
    LOOP    MLOOP2    ; and do this 100 times
    CALL    LFCR    ; finished with one line we send normal line-end
    CALL    BREAK?    ; check for an ESC if we want to abort
    OR    AL,AL    ; clear flags
    DEC    DH    ; DH is our line counter,
    CMP    DH,0    ; when it goes 0 we're done.
    JZ    TOF    ; so we'll try to reset Top of Form and exit
    INC    CS:WHERESI    ; else go to the next byte location
    MOV    SI,CS:WHERESI    ; store
    JMP    MAIN2A        ; and do again
TOF:    MOV    CX,19    ; tof restores page to 11 inches from where it started
TOFL:    MOV    AL,13    ; send a bunch of cr's and lf's
    CALL    SEND2    ; put BREAK? in here somehow
    MOV    AL,10
    CALL    SEND2
    CALL    BREAK?    ; check for early exit
    LOOP    TOFL    ; on and on.
; This restores the EPSON to 6 lines per inch
; ESC @ = Restore all settings to default
    IF    EPSON
    MOV    AL,27    ; esc
    CALL    SEND2
    MOV    AL,64    ; @
    CALL    SEND2
    ENDIF
;    IF    CITOH    ; No equivalent to Epson ESC @
;    MOV    AL,27    ; for CITOH
;    CALL    SEND2    ; so just reset line feed pitch
;    MOV    AL,'A'  ; this is done by DONE anyway
;    CALL    SEND2    ; so leave open if someone wants to patch
;    ENDIF
    IF    OTHER
    ORESET
    ENDIF
    JMP    DONE    ; clean up and back to caller.
START    ENDP
SEND2    PROC    NEAR    ; BIOS routine to print the character in AL
    PUSH    AX
    MOV    AH,00H    ; 0=print, 1=initialize port, 2=read status to AH
    PUSH    DX
    MOV    DX,0    ; DX specifies printer 0 (LPT1:)
    INT    17H    ; BIOS used instead of DOS because DOS sends
    POP    DX    ; CR/LF's in the middle of the bit-plots
    TEST    AH,29h    ; check for timeout or errors or out-of-paper
    POP    AX
    JNZ    ERRET
    RET
ERRET:    MOV    AX,00FFH ; Flag for printer foulup
    MOV    SP,BP
    PUSH    AX
    JMP    EDONE    ; special abort
SEND2    ENDP
; EPSON bit plots operate at 480 or 960 dots across the page
; called by ESC K 'low byte';'high byte'
;  i.e.  300 dots would be 256+44 or 012CH
;  This is sent to the EPSON as --> 1b 4b 2c 01
;        or in decimal    --> 27 75 44 1
INDENT    PROC    NEAR
    PUSH    CX    ; 13 SPACES IN TO CENTER
    IF    EPSON
    MOV    CX,13    ; PICTURE ( we've got 320 dots and 480 to work with
INLOP:    MOV    AL,20H    ; 480-320=160 / 6 dots per char. = 26.67 extra
    CALL    SEND2    ; so indent the picture 13 spaces to center
    LOOP    INLOP
; ESC K 64 1  = 256+64=320 bit plot type bytes on the way
    MOV    AL,27    ; SEQUENCE TO SET UP 320
    CALL    SEND2    ; BIT PLOTS IN 480 MODE
    MOV    AL,75    ; OF MX-80
    CALL    SEND2    ; This is the set-up for the small print
    MOV    AL,64
    CALL    SEND2
    MOV    AL,1
    CALL    SEND2
    ENDIF
    IF    CITOH
    MOV    AL,27    ; ESC N = Pica pitch
    CALL    SEND2
    MOV    AL,'N'
    CALL    SEND2
    MOV    CX,20    ; PICTURE ( we've got 320 dots and 640 to work with
INLOP:    MOV    AL,20H    ; 640-320=320 / 8 dots per char. = 40 extra
    CALL    SEND2    ; so indent the picture 13 spaces to center
    LOOP    INLOP
; ESC S 0320 = 320 bit plot type bytes on the way
    MOV    AL,27    ; SEQUENCE TO SET UP 320
    CALL    SEND2    ; BIT PLOTS IN 640 MODE
    MOV    AL,'S'  ; OF CITOH
    CALL    SEND2    ; This is the set-up for the small print
    MOV    AL,'0'  ; Would love to try to use all 640 bits here
    CALL    SEND2    ; but have no way of testing routine.
    MOV    AL,'3'
    CALL    SEND2
    MOV    AL,'2'
    CALL    SEND2
    MOV    AL,'0'
    CALL    SEND2
    ENDIF
    IF    OTHER
    BP1
    ENDIF
    POP    CX
    RET
INDENT    ENDP
; This is indent for LARGE print
; This time we have 400 bit plots to send (200 lines x 2)
; 480-400=80 / 6 = 13.3 extra
INDENT2 PROC    NEAR
    PUSH    CX
    IF    EPSON
    MOV    CX,6    ; so indent 6 character type spaces
INLOP2: MOV    AL,20H
    CALL    SEND2
    LOOP    INLOP2
; ESC 27 K 144 1 = 256+144=400 bit-plots
    MOV    AL,27
    CALL    SEND2
    MOV    AL,75
    CALL    SEND2
    MOV    AL,144
    CALL    SEND2
    MOV    AL,1
    CALL    SEND2
    ENDIF
; 640-400=240 / 8 = 30 EXTRA characters
    IF    CITOH
    MOV    AL,27    ; ESC N = Pica pitch
    CALL    SEND2
    MOV    AL,'N'
    CALL    SEND2
    MOV    CX,15    ; PICTURE ( we've got 400 dots and 640 to work with
INLOP2: MOV    AL,20H    ; 640-400 / 8 dots per char. = 30 extra
    CALL    SEND2    ; so indent the picture 15 spaces to center
    LOOP    INLOP2
; ESC S 0400 = 400 bit plot type bytes on the way
    MOV    AL,27    ; SEQUENCE TO SET UP 400
    CALL    SEND2    ; BIT PLOTS IN 640 MODE
    MOV    AL,'S'  ; OF CITOH
    CALL    SEND2
    MOV    AL,'0'
    CALL    SEND2
    MOV    AL,'4'
    CALL    SEND2
    MOV    AL,'0'
    CALL    SEND2
    MOV    AL,'0'
    CALL    SEND2
    ENDIF
    IF    OTHER
    BP2
    ENDIF
    POP    CX
    RET
INDENT2 ENDP
TST4    PROC    NEAR    ;  This routine builds ONE bit plot byte
    MOV    AX,80    ;  by testing a dot with the mask sent
    SUB    AX,CX    ;  from MLOOP.
    MOV    SI,AX    ;  First it does the ODD row then the EVEN
    MOV    AH,0    ;  since alternate lines are offset 2000h
    MOV    AL,[SI] ;  from each other in memory.
    AND    AL,DL    ;  DL has the mask
    CMP    AL,0    ;  SI the location
    JZ    NO7    ;  AL the memory byte
    CALL    SET7    ;  AH is the byte being built
NO7:    ADD    SI,80    ; +80 gets us from say 0,0 to 2,0
    MOV    AL,[SI] ; get the memory byte ( 4 dots )
    AND    AL,DL    ; get rid of dots we aren't testing now
    CMP    AL,0    ; see if its COLOR 0
    JZ    NO5    ; if yes, go on
    CALL    SET5    ; otherwise set that bit
NO5:    ADD    SI,80    ; continue 7 5 3 1
    MOV    AL,[SI]
    AND    AL,DL
    CMP    AL,0
    JZ    NO3
    CALL    SET3
NO3:    ADD    SI,80
    MOV    AL,[SI]
    AND    AL,DL
    CMP    AL,0
    JZ    NO1
    CALL    SET1
NO1:    PUSH    AX
    MOV    AX,80
    SUB    AX,CX    ; CX counts our screen position
    ADD    AX,2000H ; add 2000h for the EVEN rows
    MOV    SI,AX    ; with seg set to B800h we can use SI like an
    POP    AX    ; array pointer ( AH has our byte so don't lose )
    MOV    AL,[SI] ; and continue with the same idea for 6 4 2 0
    AND    AL,DL
    CMP    AL,0
    JZ    NO6
    CALL    SET6
NO6:    ADD    SI,80
    MOV    AL,[SI]
    AND    AL,DL
    CMP    AL,0
    JZ    NO4
    CALL    SET4
NO4:    ADD    SI,80
    MOV    AL,[SI]
    AND    AL,DL
    CMP    AL,0
    JZ    NO2
    CALL    SET2
NO2:    ADD    SI,80
    MOV    AL,[SI]
    AND    AL,DL
    CMP    AL,0
    JZ    NO0
    CALL    SET0
NO0:    RET
; where's my Z80 now
; reverse this table if your bit plots use bit 0 for the top wire
    IF    BIT7
SET7:    OR    AH,80H    ; top wire - bit 7
    RET
SET6:    OR    AH,40H    ; bit 6
    RET
SET5:    OR    AH,20H    ; bit 5
    RET
SET4:    OR    AH,10H    ; bit 4
    RET
SET3:    OR    AH,08H    ; bit 3
    RET
SET2:    OR    AH,04H    ; bit 2
    RET
SET1:    OR    AH,02H    ; bit 1
    RET
SET0:    OR    AH,01H    ; bit 0
    RET
    ENDIF
    IF    BIT0
SET7:    OR    AH,01H    ; top wire - bit 0
    RET
SET6:    OR    AH,02H    ; bit 1
    RET
SET5:    OR    AH,04H    ; bit 2
    RET
SET4:    OR    AH,08H    ; bit 3
    RET
SET3:    OR    AH,10H    ; bit 4
    RET
SET2:    OR    AH,20H    ; bit 5
    RET
SET1:    OR    AH,40H    ; bit 6
    RET
SET0:    OR    AH,80H    ; bit 7
    RET
    ENDIF
TST4    ENDP
; This routine pre-scans a line to see if in fact there are any bit
; plots to send. The main routine will keep sending bytes here
; If a whole line of 0's are sent we avoid going through the
; set-up for bit-plot (i.e. slower movement) graphics when a CR/LF
; would take care of everything.
; If there IS something to send, PTFLAG is set, the current line
; position is set to 0, bit-plot is init., and bits are really sent to printer.
SEND    PROC    NEAR
    PUSH    AX    ; save the character
    PUSH    DS    ; DS saved cause it points to lines
    MOV    AX,CS    ; set seg for here
    MOV    DS,AX    ; This was some of my first stuff with the 8088
    POP    AX    ; and I see some needless complexity here now
    MOV    CS:DSTOR,AX    ; but it works and if I mess with it
    CMP    CS:PTFLAG,0FFH    ; its back to DEBUG.
    JNZ    NOSEND    ; if PTFLAG isn't FFh we are still scanning
    POP    AX    ; else get the char. in AL and print it
    CALL    SEND2    ; this is the real out to printer routine
    JMP    SHORT NOSET ; restore DS and return
NOSEND: POP    AX    ; This is the SCAN routine
    CMP    AL,0    ; get the char. > test for 0 > if so reset and go back
    JZ    NOSET
    MOV    AL,0FFH ; if <> 0
    MOV    CS:PTFLAG,AL ; set PTFLAG to go
    POP    AX    ;DISCARD RETURN
    CMP    CS:ONEOR2,1 ; check which (small or LARGE)
    JNZ    TWO    ; indent 6 or 13 depending on which routine
    CALL    INDENT    ; indent also sets up bit-plot mode
    CALL    NOSET    ; NOSET will restore DS to right pos.
    JMP    MAIN    ; and do the line for real.
TWO:    CALL    INDENT2 ; init. for LARGE
    MOV    SI,CS:WHERESI    ; SI set back to start of line
    CALL    NOSET    ; get right DS
    JMP    MAIN2A    ; back to beginning
NOSET:    PUSH    AX    ; routine to restore DS
    MOV    AX,CS:DSTOR
    MOV    DS,AX
    POP    AX
    RET
SEND    ENDP
LFCR    PROC    NEAR    ; send a regular CR/LF combo
    MOV    AL,13
    CALL    SEND2
    MOV    AL,10
    CALL    SEND2
    MOV    AX,0
    MOV    CS:PTFLAG,AL ; reset PTFLAG for next line
    MOV    AX,CS:DSTOR  ; restore DS
    MOV    DS,AX
    RET        ; onward
LFCR    ENDP
BREAK?    PROC    NEAR    ; Test for early exit
    PUSH    AX    ; don't lose any regs. here
    PUSH    DX
    MOV    AH,06H    ; call direct keyboard io (constat)
    MOV    DL,0FFH ; if we got a char. go check it.
    INT    21H
    JNZ    GOBACK? ; if zero flag clear we have a character
BCONT:    POP    DX    ; no char. return
    POP    AX
    RET
GOBACK?:
    CMP    AL,1BH    ; ESC
    JZ    BACK    ; so go back, else return
    JMP    SHORT BCONT    ; no ESC exit
BACK:    POP    DX    ; ESC exit This doesn't check for Ctrl-Break
    POP    AX    ; so if it is hit we save it for the caller to handle
    POP    AX    ;DISCARD RETURN
    JMP    DONE    ; and go back to orig. caller
BREAK?    ENDP
FLIPFLOP    PROC NEAR    ; This creates different combinations
    PUSH    CX    ; of a box of four bit-plot dots for one color dot.
    PUSH    BX    ; Don't lose any variables or loop counters
    PUSH    AX
    MOV    CL,2    ; AL has present bit-plot finished byte
    MOV    BX,0
    AND    AL,3    ; 00000011b
    CALL    FLIP
    ROR    BL,CL    ; 11000000b
    POP    AX    ; basically rotate bits around for
    PUSH    AX    ; o x
    CALL    R2    ; x o    color 1
    AND    AL,3    ; and
    CALL    FLIP    ; o x
    ROR    BL,CL    ; o x    color 2
    POP    AX    ; instead of
    PUSH    AX    ; x o
    CALL    R4    ; x o    color 1
    AND    AL,3    ; and
    CALL    FLIP    ; o x
    ROR    BL,CL    ; o x    color 2
    POP    AX    ; which aren't to convincing as
    CALL    R6    ; two different colors
    AND    AL,3
    CALL    FLIP
    ROR    BL,CL
    MOV    AL,BL
    POP    BX
    POP    CX
    RET
R6:    ROR    AL,CL
R4:    ROR    AL,CL
R2:    ROR    AL,CL
    RET
FLIP:    CMP    AL,3    ; make sure there are two dots for color 1 and 2
    JNZ    FLIP2
    OR    BL,3
FLIP2:    CMP    AL,2
    JNZ    FLIP3
    OR    BL,1
FLIP3:    CMP    AL,1
    JNZ    FLIP4
    OR    BL,1
FLIP4:    RET
FLIPFLOP    ENDP
REVERSE PROC    NEAR    ; take AL and make bit 0 bit 7 , 1 - 6, etc
    PUSH    DX    ; Save our counters and masks
    PUSH    CX
    MOV    DL,01H    ; 00000001B
    MOV    DH,80H    ; 10000000B
    MOV    AH,00H    ; start out blank
    MOV    CX,8    ; set counter for 8 times through
REV1:    TEST    AL,DL    ; see if bit is set
    JZ    REV2    ; if not skip next step
    OR    AH,DH    ; else set bit in AH
REV2:    SHL    DL,1    ; shift left test bit
    SHR    DH,1    ; shift right mask bit (pad other bits with 0)
    LOOP    REV1    ; do this 8 times
    MOV    AL,AH    ; and we have a reversed character.
    POP    CX    ; get back these
    POP    DX
    RET        ; and back to caller
REVERSE ENDP
LAST    DW    0
CSEG    ENDS
    END    INIT
sed